{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "259c89bc",
   "metadata": {},
   "source": [
    "# Probability mass functions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c74d6411",
   "metadata": {},
   "outputs": [],
   "source": [
    "from os.path import basename, exists\n",
    "\n",
    "\n",
    "def download(url):\n",
    "    filename = basename(url)\n",
    "    if not exists(filename):\n",
    "        from urllib.request import urlretrieve\n",
    "\n",
    "        local, _ = urlretrieve(url, filename)\n",
    "        print(\"Downloaded \" + local)\n",
    "\n",
    "\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkstats2.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkplot.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/nsfg.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/first.py\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "705e03ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloaded first.py\n"
     ]
    }
   ],
   "source": [
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dct\")\n",
    "download(\n",
    "    \"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dat.gz\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeed5af8",
   "metadata": {},
   "source": [
    "## Pmfs\n",
    "\n",
    "Another way to represent a distribution is a **probability mass\n",
    "function** (PMF), which maps from each value to its probability. A\n",
    "**probability** is a frequency expressed as a fraction of the sample\n",
    "size, `n`. To get from frequencies to probabilities, we divide through\n",
    "by `n`, which is called **normalization**.\n",
    "\n",
    "Given a Hist, we can make a dictionary that maps from each value to its\n",
    "probability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3a4e280b",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = hist.Total()\n",
    "d = {}\n",
    "for x, freq in hist.Items():\n",
    "    d[x] = freq / n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b631fb0a",
   "metadata": {},
   "source": [
    "Or we can use the Pmf class provided by `thinkstats2`. Like Hist, the\n",
    "Pmf constructor can take a list, pandas Series, dictionary, Hist, or\n",
    "another Pmf object. Here's an example with a simple list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3fff30ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pmf({1: 0.2, 2: 0.4, 3: 0.2, 5: 0.2})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import thinkstats2\n",
    "pmf = thinkstats2.Pmf([1, 2, 2, 3, 5])\n",
    "pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff05014f",
   "metadata": {},
   "source": [
    "The Pmf is normalized so total probability is 1.\n",
    "\n",
    "Pmf and Hist objects are similar in many ways; in fact, they inherit\n",
    "many of their methods from a common parent class. For example, the\n",
    "methods `Values` and `Items` work the same way for both. The biggest\n",
    "difference is that a Hist maps from values to integer counters; a Pmf\n",
    "maps from values to floating-point probabilities.\n",
    "\n",
    "To look up the probability associated with a value, use `Prob`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2ac2919b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmf.Prob(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1350ecaa",
   "metadata": {},
   "source": [
    "The bracket operator is equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "66c782c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmf[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98af6144",
   "metadata": {},
   "source": [
    "You can modify an existing Pmf by incrementing the probability\n",
    "associated with a value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b53f5742",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6000000000000001"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmf.Incr(2, 0.2)\n",
    "pmf.Prob(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4de74dd",
   "metadata": {},
   "source": [
    "Or you can multiply a probability by a factor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "df663bda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmf.Mult(2, 0.5)\n",
    "pmf.Prob(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3abe8d9e",
   "metadata": {},
   "source": [
    "If you modify a Pmf, the result may not be normalized; that is, the\n",
    "probabilities may no longer add up to 1. To check, you can call `Total`,\n",
    "which returns the sum of the probabilities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "864a09be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8999999999999999"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmf.Total()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bce848f1",
   "metadata": {},
   "source": [
    "To renormalize, call `Normalize`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a06845d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmf.Normalize()\n",
    "pmf.Total()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94f5f531",
   "metadata": {},
   "source": [
    "Pmf objects provide a `Copy` method so you can make and modify a copy\n",
    "without affecting the original.\n",
    "\n",
    "My notation in this section might seem inconsistent, but there is a\n",
    "system: I use Pmf for the name of the class, `pmf` for an instance of\n",
    "the class, and PMF for the mathematical concept of a probability mass\n",
    "function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4133bcf7",
   "metadata": {},
   "source": [
    "## Plotting PMFs\n",
    "\n",
    "`thinkplot` provides two ways to plot Pmfs:\n",
    "\n",
    "-   To plot a Pmf as a bar graph, you can use `thinkplot.Hist`. Bar\n",
    "    graphs are most useful if the number of values in the Pmf is small.\n",
    "\n",
    "-   To plot a Pmf as a step function, you can use `thinkplot.Pmf`. This\n",
    "    option is most useful if there are a large number of values and the\n",
    "    Pmf is smooth. This function also works with Hist objects.\n",
    "\n",
    "In addition, `pyplot` provides a function called `hist` that takes a\n",
    "sequence of values, computes a histogram, and plots it. Since I use Hist\n",
    "objects, I usually don't use `pyplot.hist`.\n",
    "\n",
    "![PMF of pregnancy lengths for first babies and others, using bar graphs\n",
    "and step functions.](figs/probability_nsfg_pmf.pdf){height=\"3.0in\"}\n",
    "\n",
    "Figure [\\[probability_nsfg_pmf\\]](#probability_nsfg_pmf){reference-type=\"ref\"\n",
    "reference=\"probability_nsfg_pmf\"} shows PMFs of pregnancy length for\n",
    "first babies and others using bar graphs (left) and step functions\n",
    "(right).\n",
    "\n",
    "By plotting the PMF instead of the histogram, we can compare the two\n",
    "distributions without being mislead by the difference in sample size.\n",
    "Based on this figure, first babies seem to be less likely than others to\n",
    "arrive on time (week 39) and more likely to be a late (weeks 41 and 42).\n",
    "\n",
    "Here's the code that generates\n",
    "Figure [\\[probability_nsfg_pmf\\]](#probability_nsfg_pmf){reference-type=\"ref\"\n",
    "reference=\"probability_nsfg_pmf\"}:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "907e310f",
   "metadata": {},
   "outputs": [],
   "source": [
    "live, firsts, others = first.MakeFrames()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cdb7a2c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_pmf = thinkstats2.Pmf(firsts.prglngth, label=\"firsts\")\n",
    "other_pmf = thinkstats2.Pmf(others.prglngth, label=\"others\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9600cf18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 800x600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "width = 0.45\n",
    "axis = [27, 46, 0, 0.6]\n",
    "\n",
    "thinkplot.PrePlot(2, cols=2)\n",
    "thinkplot.Hist(first_pmf, align='right', width=width)\n",
    "thinkplot.Hist(other_pmf, align='left', width=width)\n",
    "thinkplot.Config(xlabel='weeks',\n",
    "                 ylabel='probability',\n",
    "                 axis=axis)\n",
    "\n",
    "thinkplot.PrePlot(2)\n",
    "thinkplot.SubPlot(2)\n",
    "thinkplot.Pmfs([first_pmf, other_pmf])\n",
    "thinkplot.Show(xlabel='weeks',\n",
    "               axis=axis)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d57e2b30",
   "metadata": {},
   "source": [
    "`PrePlot` takes optional parameters `rows` and `cols` to make a grid of\n",
    "figures, in this case one row of two figures. The first figure (on the\n",
    "left) displays the Pmfs using `thinkplot.Hist`, as we have seen before.\n",
    "\n",
    "The second call to `PrePlot` resets the color generator. Then `SubPlot`\n",
    "switches to the second figure (on the right) and displays the Pmfs using\n",
    "`thinkplot.Pmfs`. I used the `axis` option to ensure that the two\n",
    "figures are on the same axes, which is generally a good idea if you\n",
    "intend to compare two figures."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb0948b1",
   "metadata": {},
   "source": [
    "## Other visualizations\n",
    "\n",
    "Histograms and PMFs are useful while you are exploring data and trying\n",
    "to identify patterns and relationships. Once you have an idea what is\n",
    "going on, a good next step is to design a visualization that makes the\n",
    "patterns you have identified as clear as possible.\n",
    "\n",
    "In the NSFG data, the biggest differences in the distributions are near\n",
    "the mode. So it makes sense to zoom in on that part of the graph, and to\n",
    "transform the data to emphasize differences:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "59ed702f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weeks = range(35, 46)\n",
    "diffs = []\n",
    "for week in weeks:\n",
    "    p1 = first_pmf.Prob(week)\n",
    "    p2 = other_pmf.Prob(week)\n",
    "    diff = 100 * (p1 - p2)\n",
    "    diffs.append(diff)\n",
    "\n",
    "thinkplot.Bar(weeks, diffs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17576d2e",
   "metadata": {},
   "source": [
    "In this code, `weeks` is the range of weeks; `diffs` is the difference\n",
    "between the two PMFs in percentage points.\n",
    "Figure [\\[probability_nsfg_diffs\\]](#probability_nsfg_diffs){reference-type=\"ref\"\n",
    "reference=\"probability_nsfg_diffs\"} shows the result as a bar chart.\n",
    "This figure makes the pattern clearer: first babies are less likely to\n",
    "be born in week 39, and somewhat more likely to be born in weeks 41 and\n",
    "42.\n",
    "\n",
    "![Difference, in percentage points, by\n",
    "week.](figs/probability_nsfg_diffs.pdf){height=\"2.5in\"}\n",
    "\n",
    "For now we should hold this conclusion only tentatively. We used the\n",
    "same dataset to identify an apparent difference and then chose a\n",
    "visualization that makes the difference apparent. We can't be sure this\n",
    "effect is real; it might be due to random variation. We'll address this\n",
    "concern later."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51fc69ca",
   "metadata": {},
   "source": [
    "## The class size paradox\n",
    "\n",
    "Before we go on, I want to demonstrate one kind of computation you can\n",
    "do with Pmf objects; I call this example the \"class size paradox.\"\n",
    "\n",
    "At many American colleges and universities, the student-to-faculty ratio\n",
    "is about 10:1. But students are often surprised to discover that their\n",
    "average class size is bigger than 10. There are two reasons for the\n",
    "discrepancy:\n",
    "\n",
    "-   Students typically take 4--5 classes per semester, but professors\n",
    "    often teach 1 or 2.\n",
    "\n",
    "-   The number of students who enjoy a small class is small, but the\n",
    "    number of students in a large class is (ahem!) large.\n",
    "\n",
    "The first effect is obvious, at least once it is pointed out; the second\n",
    "is more subtle. Let's look at an example. Suppose that a college offers\n",
    "65 classes in a given semester, with the following distribution of\n",
    "sizes:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d14e5f73",
   "metadata": {},
   "source": [
    "size      count\n",
    "     5- 9          8\n",
    "    10-14          8\n",
    "    15-19         14\n",
    "    20-24          4\n",
    "    25-29          6\n",
    "    30-34         12\n",
    "    35-39          8\n",
    "    40-44          3\n",
    "    45-49          2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7551d814",
   "metadata": {},
   "source": [
    "If you ask the Dean for the average class size, he would construct a\n",
    "PMF, compute the mean, and report that the average class size is 23.7.\n",
    "Here's the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6f8eb2c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean 23.692307692307693\n"
     ]
    }
   ],
   "source": [
    "d = { 7: 8, 12: 8, 17: 14, 22: 4, \n",
    "      27: 6, 32: 12, 37: 8, 42: 3, 47: 2 }\n",
    "\n",
    "pmf = thinkstats2.Pmf(d, label='actual')\n",
    "print('mean', pmf.Mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d22bd69",
   "metadata": {},
   "source": [
    "But if you survey a group of students, ask them how many students are in\n",
    "their classes, and compute the mean, you would think the average class\n",
    "was bigger. Let's see how much bigger.\n",
    "\n",
    "First, I compute the distribution as observed by students, where the\n",
    "probability associated with each class size is \"biased\" by the number of\n",
    "students in the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3cef6126",
   "metadata": {},
   "outputs": [],
   "source": [
    "def BiasPmf(pmf, label):\n",
    "    new_pmf = pmf.Copy(label=label)\n",
    "\n",
    "    for x, p in pmf.Items():\n",
    "        new_pmf.Mult(x, x)\n",
    "        \n",
    "    new_pmf.Normalize()\n",
    "    return new_pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1449478",
   "metadata": {},
   "source": [
    "For each class size, `x`, we multiply the probability by `x`, the number\n",
    "of students who observe that class size. The result is a new Pmf that\n",
    "represents the biased distribution.\n",
    "\n",
    "Now we can plot the actual and observed distributions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1c2b81d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 800x600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "biased_pmf = BiasPmf(pmf, label='observed')\n",
    "thinkplot.PrePlot(2)\n",
    "thinkplot.Pmfs([pmf, biased_pmf])\n",
    "thinkplot.Show(xlabel='class size', ylabel='PMF')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6820e00",
   "metadata": {},
   "source": [
    "![Distribution of class sizes, actual and as observed by\n",
    "students.](figs/class_size1.pdf){height=\"3.0in\"}\n",
    "\n",
    "Figure [\\[class_size1\\]](#class_size1){reference-type=\"ref\"\n",
    "reference=\"class_size1\"} shows the result. In the biased distribution\n",
    "there are fewer small classes and more large ones. The mean of the\n",
    "biased distribution is 29.1, almost 25% higher than the actual mean.\n",
    "\n",
    "It is also possible to invert this operation. Suppose you want to find\n",
    "the distribution of class sizes at a college, but you can't get reliable\n",
    "data from the Dean. An alternative is to choose a random sample of\n",
    "students and ask how many students are in their classes.\n",
    "\n",
    "The result would be biased for the reasons we've just seen, but you can\n",
    "use it to estimate the actual distribution. Here's the function that\n",
    "unbiases a Pmf:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4c52202b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def UnbiasPmf(pmf, label):\n",
    "    new_pmf = pmf.Copy(label=label)\n",
    "\n",
    "    for x, p in pmf.Items():\n",
    "        new_pmf.Mult(x, 1.0/x)\n",
    "        \n",
    "    new_pmf.Normalize()\n",
    "    return new_pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9728cc41",
   "metadata": {},
   "source": [
    "It's similar to `BiasPmf`; the only difference is that it divides each\n",
    "probability by `x` instead of multiplying."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e13ab03",
   "metadata": {},
   "source": [
    "## DataFrame indexing\n",
    "\n",
    "In Section [\\[dataframe\\]](#dataframe){reference-type=\"ref\"\n",
    "reference=\"dataframe\"} we read a pandas DataFrame and used it to select\n",
    "and modify data columns. Now let's look at row selection. To start, I\n",
    "create a NumPy array of random numbers and use it to initialize a\n",
    "DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2d4ef2b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.054086</td>\n",
       "      <td>0.717402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-2.266185</td>\n",
       "      <td>0.657867</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-1.375564</td>\n",
       "      <td>-2.341714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.084315</td>\n",
       "      <td>-0.997987</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1\n",
       "0  0.054086  0.717402\n",
       "1 -2.266185  0.657867\n",
       "2 -1.375564 -2.341714\n",
       "3 -0.084315 -0.997987"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas\n",
    "array = np.random.randn(4, 2)\n",
    "df = pandas.DataFrame(array)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d45137a",
   "metadata": {},
   "source": [
    "By default, the rows and columns are numbered starting at zero, but you\n",
    "can provide column names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0976de54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.054086</td>\n",
       "      <td>0.717402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-2.266185</td>\n",
       "      <td>0.657867</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-1.375564</td>\n",
       "      <td>-2.341714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.084315</td>\n",
       "      <td>-0.997987</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "0  0.054086  0.717402\n",
       "1 -2.266185  0.657867\n",
       "2 -1.375564 -2.341714\n",
       "3 -0.084315 -0.997987"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "columns = ['A', 'B']\n",
    "df = pandas.DataFrame(array, columns=columns)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14cbc3ab",
   "metadata": {},
   "source": [
    "You can also provide row names. The set of row names is called the\n",
    "**index**; the row names themselves are called **labels**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0f27395f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.054086</td>\n",
       "      <td>0.717402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>-2.266185</td>\n",
       "      <td>0.657867</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>-1.375564</td>\n",
       "      <td>-2.341714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>-0.084315</td>\n",
       "      <td>-0.997987</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  0.054086  0.717402\n",
       "b -2.266185  0.657867\n",
       "c -1.375564 -2.341714\n",
       "d -0.084315 -0.997987"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = ['a', 'b', 'c', 'd']\n",
    "df = pandas.DataFrame(array, columns=columns, index=index)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8e6ab1f",
   "metadata": {},
   "source": [
    "As we saw in the previous chapter, simple indexing selects a column,\n",
    "returning a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "cbdfb26d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.054086\n",
       "b   -2.266185\n",
       "c   -1.375564\n",
       "d   -0.084315\n",
       "Name: A, dtype: float64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['A']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ada6edd9",
   "metadata": {},
   "source": [
    "To select a row by label, you can use the `loc` attribute, which returns\n",
    "a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8a56eb2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    0.054086\n",
       "B    0.717402\n",
       "Name: a, dtype: float64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc['a']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2bdfc2",
   "metadata": {},
   "source": [
    "If you know the integer position of a row, rather than its label, you\n",
    "can use the `iloc` attribute, which also returns a Series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "a542ac35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    0.054086\n",
       "B    0.717402\n",
       "Name: a, dtype: float64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65fe785e",
   "metadata": {},
   "source": [
    "`loc` can also take a list of labels; in that case, the result is a\n",
    "DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f3c26591",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.054086</td>\n",
       "      <td>0.717402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>-1.375564</td>\n",
       "      <td>-2.341714</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  0.054086  0.717402\n",
       "c -1.375564 -2.341714"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = ['a', 'c']\n",
    "df.loc[indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84f4d2f1",
   "metadata": {},
   "source": [
    "Finally, you can use a slice to select a range of rows by label:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7b9ad87c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.054086</td>\n",
       "      <td>0.717402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>-2.266185</td>\n",
       "      <td>0.657867</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>-1.375564</td>\n",
       "      <td>-2.341714</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  0.054086  0.717402\n",
       "b -2.266185  0.657867\n",
       "c -1.375564 -2.341714"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['a':'c']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "644ffd7a",
   "metadata": {},
   "source": [
    "Or by integer position:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "76eaf08a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.054086</td>\n",
       "      <td>0.717402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>-2.266185</td>\n",
       "      <td>0.657867</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  0.054086  0.717402\n",
       "b -2.266185  0.657867"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0009a9a5",
   "metadata": {},
   "source": [
    "The result in either case is a DataFrame, but notice that the first\n",
    "result includes the end of the slice; the second doesn't.\n",
    "\n",
    "My advice: if your rows have labels that are not simple integers, use\n",
    "the labels consistently and avoid using integer positions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee9e9b68",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "Solutions to these exercises are in `chap03soln.ipynb` and\n",
    "`chap03soln.py`\n",
    "\n",
    "### Exercise\n",
    "Something like the class size paradox appears if you survey children and\n",
    "ask how many children are in their family. Families with many children\n",
    "are more likely to appear in your sample, and families with no children\n",
    "have no chance to be in the sample.\n",
    "\n",
    "Use the NSFG respondent variable `NUMKDHH` to construct the actual\n",
    "distribution for the number of children under 18 in the household.\n",
    "\n",
    "Now compute the biased distribution we would see if we surveyed the\n",
    "children and asked them how many children under 18 (including\n",
    "themselves) are in their household.\n",
    "\n",
    "Plot the actual and biased distributions, and compute their means. As a\n",
    "starting place, you can use `chap03ex.ipynb`.\n",
    "\n",
    "\n",
    "### Exercise\n",
    "In Section [\\[mean\\]](#mean){reference-type=\"ref\" reference=\"mean\"} we\n",
    "computed the mean of a sample by adding up the elements and dividing by\n",
    "n. If you are given a PMF, you can still compute the mean, but the\n",
    "process is slightly different: $$\\xbar = \\sum_i p_i~x_i$$ where the\n",
    "$x_i$ are the unique values in the PMF and $p_i=PMF(x_i)$. Similarly,\n",
    "you can compute variance like this: $$S^2 = \\sum_i p_i~(x_i - \\xbar)^2$$\n",
    "Write functions called `PmfMean` and `PmfVar` that take a Pmf object and\n",
    "compute the mean and variance. To test these methods, check that they\n",
    "are consistent with the methods `Mean` and `Var` provided by Pmf.\n",
    "\n",
    "\n",
    "### Exercise\n",
    "I started with the question, \"Are first babies more likely to be late?\"\n",
    "To address it, I computed the difference in means between groups of\n",
    "babies, but I ignored the possibility that there might be a difference\n",
    "between first babies and others *for the same woman*.\n",
    "\n",
    "To address this version of the question, select respondents who have at\n",
    "least two babies and compute pairwise differences. Does this formulation\n",
    "of the question yield a different result?\n",
    "\n",
    "Hint: use `nsfg.MakePregMap`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ea357ae",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "In most foot races, everyone starts at the same time. If you are a fast\n",
    "runner, you usually pass a lot of people at the beginning of the race,\n",
    "but after a few miles everyone around you is going at the same speed.\n",
    "\n",
    "When I ran a long-distance (209 miles) relay race for the first time, I\n",
    "noticed an odd phenomenon: when I overtook another runner, I was usually\n",
    "much faster, and when another runner overtook me, he was usually much\n",
    "faster.\n",
    "\n",
    "At first I thought that the distribution of speeds might be bimodal;\n",
    "that is, there were many slow runners and many fast runners, but few at\n",
    "my speed.\n",
    "\n",
    "Then I realized that I was the victim of a bias similar to the effect of\n",
    "class size. The race was unusual in two ways: it used a staggered start,\n",
    "so teams started at different times; also, many teams included runners\n",
    "at different levels of ability.\n",
    "\n",
    "As a result, runners were spread out along the course with little\n",
    "relationship between speed and location. When I joined the race, the\n",
    "runners near me were (pretty much) a random sample of the runners in the\n",
    "race.\n",
    "\n",
    "So where does the bias come from? During my time on the course, the\n",
    "chance of overtaking a runner, or being overtaken, is proportional to\n",
    "the difference in our speeds. I am more likely to catch a slow runner,\n",
    "and more likely to be caught by a fast runner. But runners at the same\n",
    "speed are unlikely to see each other.\n",
    "\n",
    "Write a function called `ObservedPmf` that takes a Pmf representing the\n",
    "actual distribution of runners' speeds, and the speed of a running\n",
    "observer, and returns a new Pmf representing the distribution of\n",
    "runners' speeds as seen by the observer.\n",
    "\n",
    "To test your function, you can use `relay.py`, which reads the results\n",
    "from the James Joyce Ramble 10K in Dedham MA and converts the pace of\n",
    "each runner to mph.\n",
    "\n",
    "Compute the distribution of speeds you would observe if you ran a relay\n",
    "race at 7.5 mph with this group of runners. A solution to this exercise\n",
    "is in `relay_soln.py`.\n",
    "\n",
    "\n",
    "## Glossary\n",
    "\n",
    "-   **Probability mass function (PMF)**: a representation of a\n",
    "    distribution as a function that maps from values to probabilities.\n",
    "\n",
    "-   **probability**: A frequency expressed as a fraction of the sample\n",
    "    size.\n",
    "\n",
    "-   **normalization**: The process of dividing a frequency by a sample\n",
    "    size to get a probability.\n",
    "\n",
    "-   **index**: In a pandas DataFrame, the index is a special column that\n",
    "    contains the row labels."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e818cde9",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5656a301",
   "metadata": {},
   "source": [
    "**Exercise:** In Chapter 3 we computed the mean of a sample by adding up\n",
    "the elements and dividing by n.  If you are given a PMF, you can\n",
    "still compute the mean, but the process is slightly different:\n",
    "%\n",
    "$$ \\bar x = \\sum_i p_i~x_i $$\n",
    "%\n",
    "where the $x_i$ are the unique values in the PMF and $p_i=PMF(x_i)$.\n",
    "Similarly, you can compute variance like this:\n",
    "%\n",
    "$$ S^2 = \\sum_i p_i~(x_i - \\bar x)^2 $$\n",
    "% \n",
    "Write functions called `PmfMean` and `PmfVar` that take a\n",
    "Pmf object and compute the mean and variance.  To test these methods,\n",
    "check that they are consistent with the methods `Mean` and `Var`\n",
    "provided by `Pmf`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c055d849",
   "metadata": {},
   "outputs": [],
   "source": [
    "def PmfMean(pmf):\n",
    "    \"\"\"Computes the mean of a PMF.\n",
    "    Returns:\n",
    "        float mean\n",
    "    \"\"\"\n",
    "    return sum(p * x for x, p in pmf.Items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2a809c50",
   "metadata": {},
   "outputs": [],
   "source": [
    "def PmfVar(pmf, mu=None):\n",
    "    \"\"\"Computes the variance of a PMF.\n",
    "    mu: the point around which the variance is computed;\n",
    "            if omitted, computes the mean\n",
    "    returns: float variance\n",
    "    \"\"\"\n",
    "    if mu is None:\n",
    "        mu = PmfMean(pmf)\n",
    "\n",
    "    return sum(p * (x - mu) ** 2 for x, p in pmf.Items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81e26051",
   "metadata": {},
   "source": [
    "**Exercise:** Something like the class size paradox appears if you survey children and ask how many children are in their family. Families with many children are more likely to appear in your sample, and families with no children have no chance to be in the sample.\n",
    "\n",
    "Use the NSFG respondent variable `numkdhh` to construct the actual distribution for the number of children under 18 in the respondents' households.\n",
    "\n",
    "Now compute the biased distribution we would see if we surveyed the children and asked them how many children under 18 (including themselves) are in their household.\n",
    "\n",
    "Plot the actual and biased distributions, and compute their means."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "685c5754",
   "metadata": {},
   "outputs": [],
   "source": [
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemResp.dct\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemResp.dat.gz\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "002091b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "resp = nsfg.ReadFemResp()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "994926af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "pmf = thinkstats2.Pmf(resp.numkdhh, label=\"numkdhh\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "6d8cf8f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "thinkplot.Pmf(pmf)\n",
    "thinkplot.Config(xlabel=\"Number of children\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "019396ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "biased = BiasPmf(pmf, label=\"biased\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "064c0161",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "thinkplot.PrePlot(2)\n",
    "thinkplot.Pmfs([pmf, biased])\n",
    "thinkplot.Config(xlabel=\"Number of children\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "e0c4082f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.024205155043831"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "pmf.Mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "ea9bec5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.403679100664282"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "biased.Mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9adb917d",
   "metadata": {},
   "source": [
    "**Exercise:** I started this book with the question, \"Are first babies more likely to be late?\" To address it, I computed the difference in means between groups of babies, but I ignored the possibility that there might be a difference between first babies and others for the same woman.\n",
    "\n",
    "To address this version of the question, select respondents who have at least two live births and compute pairwise differences. Does this formulation of the question yield a different result?\n",
    "\n",
    "Hint: use `nsfg.MakePregMap`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "13875390",
   "metadata": {},
   "outputs": [],
   "source": [
    "live, firsts, others = first.MakeFrames()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d9cf58d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "preg_map = nsfg.MakePregMap(live)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "b0759fdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "hist = thinkstats2.Hist()\n",
    "\n",
    "for caseid, indices in preg_map.items():\n",
    "    if len(indices) >= 2:\n",
    "        pair = preg.loc[indices[0:2]].prglngth\n",
    "        diff = np.diff(pair)[0]\n",
    "        hist[diff] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "efbf4a29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "thinkplot.Hist(hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "01d0c9e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.056367432150313125"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "pmf = thinkstats2.Pmf(hist)\n",
    "pmf.Mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "208fa6e7",
   "metadata": {},
   "source": [
    "**Exercise:** In most foot races, everyone starts at the same time. If you are a fast runner, you usually pass a lot of people at the beginning of the race, but after a few miles everyone around you is going at the same speed.\n",
    "When I ran a long-distance (209 miles) relay race for the first time, I noticed an odd phenomenon: when I overtook another runner, I was usually much faster, and when another runner overtook me, he was usually much faster.\n",
    "\n",
    "At first I thought that the distribution of speeds might be bimodal; that is, there were many slow runners and many fast runners, but few at my speed.\n",
    "\n",
    "Then I realized that I was the victim of a bias similar to the effect of class size. The race was unusual in two ways: it used a staggered start, so teams started at different times; also, many teams included runners at different levels of ability.\n",
    "\n",
    "As a result, runners were spread out along the course with little relationship between speed and location. When I joined the race, the runners near me were (pretty much) a random sample of the runners in the race.\n",
    "\n",
    "So where does the bias come from? During my time on the course, the chance of overtaking a runner, or being overtaken, is proportional to the difference in our speeds. I am more likely to catch a slow runner, and more likely to be caught by a fast runner. But runners at the same speed are unlikely to see each other.\n",
    "\n",
    "Write a function called `ObservedPmf` that takes a `Pmf` representing the actual distribution of runners’ speeds, and the speed of a running observer, and returns a new `Pmf` representing the distribution of runners’ speeds as seen by the observer.\n",
    "\n",
    "To test your function, you can use `relay.py`, which reads the results from the James Joyce Ramble 10K in Dedham MA and converts the pace of each runner to mph.\n",
    "\n",
    "Compute the distribution of speeds you would observe if you ran a relay race at 7 mph with this group of runners."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "7382158b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloaded relay.py\n",
      "Downloaded Apr25_27thAn_set1.shtml\n"
     ]
    }
   ],
   "source": [
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/relay.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/Apr25_27thAn_set1.shtml\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d6ef0e81",
   "metadata": {},
   "outputs": [],
   "source": [
    "import relay\n",
    "\n",
    "results = relay.ReadResults()\n",
    "speeds = relay.GetSpeeds(results)\n",
    "speeds = relay.BinData(speeds, 3, 12, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "93c82191",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf = thinkstats2.Pmf(speeds, \"actual speeds\")\n",
    "thinkplot.Pmf(pmf)\n",
    "thinkplot.Config(xlabel=\"Speed (mph)\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "1af42d5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "def ObservedPmf(pmf, speed, label=None):\n",
    "    \"\"\"Returns a new Pmf representing speeds observed at a given speed.\n",
    "\n",
    "    The chance of observing a runner is proportional to the difference\n",
    "    in speed.\n",
    "\n",
    "    Args:\n",
    "        pmf: distribution of actual speeds\n",
    "        speed: speed of the observing runner\n",
    "        label: string label for the new dist\n",
    "\n",
    "    Returns:\n",
    "        Pmf object\n",
    "    \"\"\"\n",
    "    new = pmf.Copy(label=label)\n",
    "    for val in new.Values():\n",
    "        diff = abs(val - speed)\n",
    "        new[val] *= diff\n",
    "    new.Normalize()\n",
    "    return new\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "534b6e85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "biased = ObservedPmf(pmf, 7, label=\"observed speeds\")\n",
    "thinkplot.Pmf(biased)\n",
    "thinkplot.Config(xlabel=\"Speed (mph)\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46da1c8f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
